package com.yidu.hbatsft.action;

import com.yidu.hbatsft.domain.AtsScheme;
import com.yidu.hbatsft.domain.AtsSchemeAthlete;
import com.yidu.hbatsft.domain.AtsSchemeExpert;
import com.yidu.hbatsft.service.AtsSchemeAthleteService;
import com.yidu.hbatsft.service.MentalityAtsSchemeAthleteService;
import com.yidu.hbatsft.service.MentalityAtsSchemeExpertService;
import com.yidu.hbatsft.service.MentalityAtsSchemeService;
import com.yidu.privilege.Domain.User;
import com.yidu.privilege.vo.UserVo;
import com.yidu.utils.FileExportTools;
import com.yidu.utils.FileTools;
import com.yidu.utils.Message;
import com.yidu.utils.Tools;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.apache.commons.lang.StringUtils;
import org.apache.poi.xwpf.usermodel.XWPFParagraph;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.text.DateFormat;
import java.util.*;

/**
  *@ClassName MentalityAtsSchemeController
  *@Description 心理训练方案控制器
  *@Author 肖瑜
  *@Date 2020/1/6 9:41
  *@Version 1.0
**/
@Controller
@RequestMapping("/mentalityas")
public class MentalityAtsSchemeController {

    //文件上传管理工具
    @Resource
    FileTools fileTools;

    //方案service
    @Resource
    MentalityAtsSchemeService mas;

    //方案对应的运动员service
    @Resource
    MentalityAtsSchemeAthleteService atsSchemeAthleteService;

    /**
     * 查询所有方案
     * @param pageNum 页数
     * @param pageSize 条数
     * @param atsScheme 方案对象
     * @param request 请求对象
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return map 集合
     */
    @ResponseBody
    @RequestMapping("findAll")
    public Map<String, Object> findAll(@RequestParam("page") Integer pageNum, @RequestParam("limit") Integer pageSize, AtsScheme atsScheme, HttpServletRequest request,String startTime,String endTime) {
        //获取session对象
        HttpSession session = request.getSession();
        //从session中拿到manager
        UserVo user = (UserVo)session.getAttribute("manager");
        //判断开始时间不为空
        if(startTime!=null&&!"".equals(startTime)){
            //根据横杠符号分割
            String[] date = startTime.split("-");
            //将数组的第一位放入方案中的年份
            atsScheme.setYear(Integer.valueOf(date[0]));
            //将数组的第二位放入方案中的月份
            atsScheme.setMonth(Integer.valueOf(date[1]));
        }
        //判断结束时间不为空
        if(endTime!=null&&!"".equals(endTime)){
            //根据横杠符号分割
            String[] date = endTime.split("-");
            //将数组的第一位放入方案中的年份
            atsScheme.setYearTwo(Integer.valueOf(date[0]));
            //将数组的第二位放入方案中的月份
            atsScheme.setMonthTwo(Integer.valueOf(date[1]));
        }
        //备注作为人员ID
        atsScheme.setRemark(String.valueOf(user.getUsWaiid()));
        //list集合
        List<AtsScheme> list = null;
        //创建map集合
        Map<String, Object> map = new HashMap<String, Object>();
        //将code设置为0
        map.put("code", 0);
        //将msg设置为空
        map.put("msg", "");
        //判断用户类型不能为空
        if(user.getUsType()!=null||!"".equals(user.getUsType())){
            //如果用户类型是专家
            if(user.getUsType().equals("专家")){
                //查询专家
                list = mas.selectExpert(pageNum, pageSize,atsScheme);
                //统计条数放入map
                map.put("count", mas.countExpert(atsScheme));
            //如果用户类型是教练
            }else if(user.getUsType().equals("教练")){
                //获取用户的外键放入教练ID
                atsScheme.setCoachId(user.getUsWaiid());
                //查询所有教练
                list = mas.findAll(pageNum, pageSize,atsScheme);
                //统计条数放入map
                map.put("count", mas.count(atsScheme));
            //如果用户类型是运动员
            }else if(user.getUsType().equals("运动员")){
                //查询运动员
                list = mas.selectAthlete(pageNum, pageSize,atsScheme);
                //统计条数放入map
                map.put("count",mas.count(atsScheme));
            //如果用户类型是领导
            }else if(user.getUsType().equals("领导")){
                //查询审核
                list =mas.selectAudit(pageNum, pageSize,atsScheme);
                //统计条数放入map
                map.put("count",mas.countAudit(atsScheme));
            }
        }
        //将集合放入map
        map.put("data", list);
        //返回map
        return map;
    }

    /**
     * 查询方案、方案对应的运动员、专家所有
     * @return list 集合
     */
    @ResponseBody
    @RequestMapping("findAllList")
    public List<AtsScheme> findAllList() {
        //调用查询方案、方案对应的运动员、专家所有方法
        List<AtsScheme> list = mas.findAllList();
        //返回list
        return list;
    }

    /**
     * 新增方案
     * @param file 文件
     * @param atsScheme 方案对象
     * @param atsSchemeAthlete 方案对应的运动员对象
     * @param selectArr 运动员
     * @param request 请求对象
     * @return message 消息对象
     */
    @ResponseBody
    @RequestMapping("addorupdate")
    public Message addOrupdate(MultipartFile file,AtsScheme atsScheme, AtsSchemeAthlete atsSchemeAthlete, String selectArr,HttpServletRequest request) {
        //定义变量
        int rows = 0;
        //将方案类型设置为心理训练方案
        atsScheme.setSchemeType("心理训练方案");
        try {
            //判断附件1的大小不为0
            if (atsScheme.getFileOne().getSize() > 0) {
                //调用保存文件方法放入附件1
                atsScheme.setFile1(fileTools.saveFile("MentalityAtsScheme", atsScheme.getFileOne()));
            }
            //判断附件2的大小不为0
            if (atsScheme.getFileTwo().getSize() > 0) {
                //调用保存文件方法放入附件2
                atsScheme.setFile2(fileTools.saveFile("MentalityAtsScheme", atsScheme.getFileTwo()));
            }
            //判断附件3的大小不为0
            if (atsScheme.getFileThree().getSize() > 0) {
                //调用保存文件方法放入附件3
                atsScheme.setFile3(fileTools.saveFile("MentalityAtsScheme", atsScheme.getFileThree()));
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
        //获取session对象
        HttpSession session = request.getSession();
        //从session中拿到manager
        UserVo user = (UserVo)session.getAttribute("manager");
        //将用户外键放入教练员ID
        atsScheme.setCoachId(user.getUsWaiid());
        //将用户名称放入教练员名称
        atsScheme.setCoachName(user.getUsName());
        //设置排序默认为1
        atsScheme.setSort(1);
        //设置创建人为用户名称
        atsScheme.setCreater(user.getUsName());
        //设置创建时间为默认当前时间
        atsScheme.setCreatTime(new Date());
        //设置是否有效默认为1
        atsScheme.setIsva(1);

        //设置方案对应的运动员的是否查看为0
        atsSchemeAthlete.setIsRead("0");
        ////设置方案对应的运动员排序为1
        atsSchemeAthlete.setSort(1);
        //设置方案对应的运动员的创建人为用户名
        atsSchemeAthlete.setCreater(user.getUsName());
        //设置方案对应的运动员的创建时间为默认当前时间
        atsSchemeAthlete.setCreatTime(new Date());
        //设置方案对应的运动员的是否有效默认为1
        atsSchemeAthlete.setIsva(1);
        //判断方案主键为空
        if (atsScheme.getSchemeId()==null) {
            //新增方案
            rows = mas.insertSelective(atsScheme);
            //将方案主键放入方案对应的运动员的方案外键中
            atsSchemeAthlete.setSchemeId(atsScheme.getSchemeId());
            //1.把字符串类型的json数组对象转化JSONArray
            JSONArray json = JSONArray.fromObject(selectArr);
            //循环json
            for(int i=0;i<json.size();i++){
                //循环获取
                JSONObject jsonObject = json.getJSONObject(i);
                //获取id值
                Integer id = (Integer)jsonObject.get("value");
                //获取名称
                String name = (String)jsonObject.get("name");
                //将id放入运动员主键
                atsSchemeAthlete.setAthleteId(id);
                //将名称放入运动员名称
                atsSchemeAthlete.setAthleteName(name);
                //新增方案对应的运动员
                rows = atsSchemeAthleteService.insert(atsSchemeAthlete);
            }
        } else {
            //修改方案 调用根据方案ID删除方案对应的运动员
            rows = atsSchemeAthleteService.deleteBySchemeId(atsScheme.getSchemeId());
            //1.把字符串类型的json数组对象转化JSONArray
            JSONArray json = JSONArray.fromObject(selectArr);
            //循环json
            for (int i = 0; i < json.size(); i++) {
                //循环获取
                JSONObject jsonObject = json.getJSONObject(i);
                //获取id值
                Integer id = (Integer) jsonObject.get("value");
                //获取名称
                String name = (String) jsonObject.get("name");
                //将id放入运动员主键
                atsSchemeAthlete.setAthleteId(id);
                //将名称放入运动员名称
                atsSchemeAthlete.setAthleteName(name);
                //新增方案对应的运动员
                atsSchemeAthleteService.insert(atsSchemeAthlete);
                //修改方案
                rows = mas.updateByPrimaryKeySelective(atsScheme);
            }
        }
        //创建消息对象
        Message message = new Message();
        //如果操作成功
        if (rows > 0) {
            message.setMsg("操作成功");
            message.setNum(1);
        //操作失败
        } else {
            message.setMsg("操作失败");
            message.setNum(0);
        }
        //返回消息
        return message;
    }

    /**
     * 根据方案ID查询方案
     * @param id 主键
     * @return AtsScheme 方案对象
     */
    @ResponseBody
    @RequestMapping("findBySchemeId")
    public AtsScheme findBySchemeId(Integer id) {
        //创建方案对象
        AtsScheme atsScheme = null;
        //id不为空
        if (id != null) {
            //调用根据方案ID查询方案方法
            atsScheme = mas.selectByPrimaryKey(id);
        }
        //返回方案
        return atsScheme;
    }

    /**
     * 逻辑删除方案
     * @param id
     * @return Message 消息对象
     */
    @ResponseBody
    @RequestMapping("delete")
    public Message delete(Integer id) {
        //创建消息对象
        Message m = new Message();
        //id不为空
        if (id != null) {
            //调用逻辑删除方案方法
            int rows = mas.updateIsvaById(id);
            //如果删除成功
            if (rows > 0) {
                m.setNum(1);
                m.setMsg("删除成功");
            //如果删除失败
            } else {
                m.setNum(1);
                m.setMsg("删除失败");
            }
        }
        //返回消息
        return m;
    }

    /**
     * 批量删除
     * @param ids 多个ID
     * @return Message 消息对象
     */
    @ResponseBody
    @RequestMapping("deleteAll")
    public Message deleteAll(String ids) {
        //创建消息对象
        Message m = new Message();
        //定义变量
        int rows = 0;
        //判断ids不为空
        if (!"".equals(ids)) {
            //分割逗号
            String[] split = ids.split(",");
            //循环
            for (String s : split) {
                //调用根据ID修改方案方法
                rows = mas.updateIsvaById(Integer.valueOf(s));
            }
            //如果成功
            if (rows > 0) {
                m.setNum(1);
                m.setMsg("删除成功");
            //失败
            } else {
                m.setNum(1);
                m.setMsg("删除失败");
            }
        }
        //返回消息
        return m;
    }

    /**
     * 反馈
     * @param atsScheme 方案对象
     * @param rsFile 反馈附件
     * @return message 消息对象
     */
    @ResponseBody
    @RequestMapping("updateResult")
    public Message updateResult(AtsScheme atsScheme,MultipartFile rsFile){
        //创建消息对象
        Message m = new Message();
        //设置反馈时间
        atsScheme.setResultTime(Tools.getCurDateTime());
        try {
            //文件大于0
            if (rsFile.getSize()>0) {
                //调用上传文件方法
                atsScheme.setResultFile(fileTools.saveFile("MentalityAtsSchemeResult",rsFile));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        //调用修改反馈方法
        int rows = mas.updateByPrimaryKeySelective(atsScheme);
        //如果成功
        if (rows > 0) {
            m.setNum(1);
            m.setMsg("反馈成功");
        //失败
        } else {
            m.setNum(1);
            m.setMsg("反馈失败");
        }
        //返回消息
        return m;
    }

    /**
     * 根据方案ID查询所有
     * @param id 方案ID
     * @return AtsScheme 方案对象
     */
    @RequestMapping("findAllById")
    @ResponseBody
    public AtsScheme findAllById(Integer id){
        //调用根据方案ID查询所有
        AtsScheme allById = mas.findAllById(id);
        //返回方案对象
        return allById;
    }


    /**
     * 根据运动员ID修改是否已查看
     * @param id
     * @param schemeId
     */
    @RequestMapping("updateByAthleteId")
    @ResponseBody
    public void updateByAthleteId(Integer id,Integer schemeId){
        //创建方案对应的运动员对象
        AtsSchemeAthlete athlete = new AtsSchemeAthlete();
        //判断运动员ID和方案ID不为空
        if((id!=null&&!"".equals(id))&&(schemeId!=null&&!"".equals(schemeId))){
            //设置运动员主键
            athlete.setAthleteId(id);
            //设置方案ID
            athlete.setSchemeId(schemeId);
            //设置是否查看
            athlete.setIsRead("1");
            //设置查看时间
            athlete.setReadTime(Tools.getCurDateTime());
            //调用根据运动员ID修改运动员
            atsSchemeAthleteService.updateByAthleteId(athlete);
        }
    }

    /**
     * 导出方案
     * @param id 方案ID
     * @param response 响应对象
     * @param request 请求对象
     */
    @RequestMapping("derive")
    @ResponseBody
    public void derive(Integer id,HttpServletResponse response,HttpServletRequest request){
        //创建方案对象
        AtsScheme atsScheme = null;
        //判断方案ID不能为空
        if (id != null) {
            //调用根据方案ID查询方案
            atsScheme = mas.selectByPrimaryKey(id);
        }
        //创建map集合
        Map<String,Object> map = new HashMap<>();
        //判断方案名不能为空
        if(atsScheme.getSchemeName()!=null){
            //放入map集合中
            map.put("1",atsScheme.getSchemeName());
        }else{
            map.put("1","无");
        }
        //判断年份不能为空
        if(atsScheme.getYear()!=null){
            map.put("2",atsScheme.getYear());
        }else{
            map.put("2"," ");
        }
        //判断月份不能为空
        if(atsScheme.getMonth()!=null){
            map.put("3",atsScheme.getMonth());
        }else{
            map.put("3"," ");
        }
        //判断方案类型不能为空
        if(atsScheme.getSchemeType()!=null){
            map.put("4",atsScheme.getSchemeType());
        }else{
            map.put("4","无");
        }
        //判断附件1不能为空
        if(atsScheme.getFile1()!=null){
            map.put("5",atsScheme.getFile1());
        }else{
            map.put("5","无");
        }
        //判断附件2不能为空
        if(atsScheme.getFile2()!=null){
            map.put("6",atsScheme.getFile2());
        }else{
            map.put("6","无");
        }
        //判断附件3不能为空
        if(atsScheme.getFile3()!=null){
            map.put("7",atsScheme.getFile3());
        }else{
            map.put("7","无");
        }
        //判断教练员姓名不能为空
        if(atsScheme.getCoachName()!=null){
            map.put("8",atsScheme.getCoachName());
        }else{
            map.put("8","无");
        }
        //判断反馈时间不能为空
        if(atsScheme.getResultTime()!=null){
            map.put("9",atsScheme.getResultTime());
        }else{
            map.put("9","无");
        }
        //判断反馈情况不能为空
        if(atsScheme.getResultExp()!=null){
            map.put("10",atsScheme.getResultExp());
        }else{
            map.put("10","无");
        }
        //判断反馈效果不能为空
        if(atsScheme.getResultEffect()!=null){
            map.put("11",atsScheme.getResultEffect());
        }else{
            map.put("11","无");
        }
        //判断反馈附件不能为空
        if(atsScheme.getResultFile()!=null){
            map.put("12",atsScheme.getResultFile());
        }else{
            map.put("12","无");
        }
        //调用导出方案方法
        FileExportTools.Export2GeotechnicalLayeringTable("fangan.doc",map,12,response,request);
    }
}
